விகித வரம்பிடல்: டோக்கன் பக்கெட் செயல்படுத்தலின் ஒரு ஆழ்ந்த பார்வை

இன்றைய ஒன்றோடொன்று இணைக்கப்பட்ட டிஜிட்டல் உலகில், பயன்பாடுகள் மற்றும் APIகளின் நிலைத்தன்மையையும் கிடைக்கும் தன்மையையும் உறுதி செய்வது மிக முக்கியமானது. விகித வரம்பிடல் பயனர்கள் அல்லது வாடிக்கையாளர்கள் கோரிக்கைகளை அனுப்பக்கூடிய விகிதத்தைக் கட்டுப்படுத்துவதன் மூலம் இந்த இலக்கை அடைவதில் ஒரு முக்கிய பங்கைக் கொண்டுள்ளது. இந்த வலைப்பதிவு இடுகை, டோக்கன் பக்கெட் வழிமுறை, அதன் செயல்படுத்தல், நன்மைகள் மற்றும் தீமைகள் ஆகியவற்றில் குறிப்பிட்ட கவனம் செலுத்தி, விகித வரம்பிடல் உத்திகளைப் பற்றிய விரிவான ஆய்வை வழங்குகிறது.

விகித வரம்பிடல் என்றால் என்ன?

விகித வரம்பிடல் என்பது ஒரு குறிப்பிட்ட காலகட்டத்தில் ஒரு சேவையகம் அல்லது சேவைக்கு அனுப்பப்படும் போக்குவரத்தின் அளவைக் கட்டுப்படுத்தப் பயன்படுத்தப்படும் ஒரு நுட்பமாகும். இது அதிகப்படியான கோரிக்கைகளால் அமைப்புகள் பாதிக்கப்படுவதைத் தடுக்கிறது, சேவை மறுப்பு (DoS) தாக்குதல்கள், துஷ்பிரயோகம் மற்றும் எதிர்பாராத போக்குவரத்து அதிகரிப்புகளைத் தடுக்கிறது. கோரிக்கைகளின் எண்ணிக்கையில் வரம்புகளைச் செயல்படுத்துவதன் மூலம், விகித வரம்பிடல் நியாயமான பயன்பாட்டை உறுதிசெய்கிறது, ஒட்டுமொத்த கணினி செயல்திறனை மேம்படுத்துகிறது மற்றும் பாதுகாப்பை மேம்படுத்துகிறது.

ஒரு ஃபிளாஷ் விற்பனையின் போது ஒரு மின்வணிக தளத்தை கருத்தில் கொள்ளுங்கள். விகித வரம்பிடல் இல்லாமல், பயனர் கோரிக்கைகளின் திடீர் எழுச்சி சேவையகங்களை மூழ்கடித்து, மெதுவான மறுமொழி நேரங்கள் அல்லது சேவை செயலிழப்புக்கு வழிவகுக்கும். ஒரு குறிப்பிட்ட காலக்கெடுவுக்குள் ஒரு பயனர் (அல்லது IP முகவரி) செய்யக்கூடிய கோரிக்கைகளின் எண்ணிக்கையைக் கட்டுப்படுத்துவதன் மூலம் விகித வரம்பிடல் இதைத் தடுக்கலாம், இது அனைத்து பயனர்களுக்கும் ஒரு சீரான அனுபவத்தை உறுதி செய்கிறது.

விகித வரம்பிடல் ஏன் முக்கியமானது?

விகித வரம்பிடல் பல நன்மைகளை வழங்குகிறது, அவற்றுள்:

• சேவை மறுப்பு (DoS) தாக்குதல்களைத் தடுத்தல்: எந்தவொரு மூலத்திலிருந்தும் கோரிக்கை விகிதத்தைக் கட்டுப்படுத்துவதன் மூலம், தீங்கிழைக்கும் போக்குவரத்து மூலம் சேவையகத்தை மூழ்கடிக்கும் நோக்கில் நடத்தப்படும் DoS தாக்குதல்களின் தாக்கத்தை விகித வரம்பிடல் குறைக்கிறது.
• துஷ்பிரயோகத்திற்கு எதிராகப் பாதுகாத்தல்: விகித வரம்பிடல், தரவுகளை சுரண்டுவது அல்லது போலி கணக்குகளை உருவாக்குவது போன்ற APIகள் அல்லது சேவைகளைத் தவறாகப் பயன்படுத்துவதிலிருந்து தீங்கிழைக்கும் நபர்களைத் தடுக்கலாம்.
• நியாயமான பயன்பாட்டை உறுதி செய்தல்: விகித வரம்பிடல் தனிப்பட்ட பயனர்கள் அல்லது வாடிக்கையாளர்கள் வளங்களைத் தனியுரிமையாக்குவதைத் தடுக்கிறது மற்றும் அனைத்து பயனர்களுக்கும் சேவையை அணுக நியாயமான வாய்ப்பு இருப்பதை உறுதி செய்கிறது.
• கணினி செயல்திறனை மேம்படுத்துதல்: கோரிக்கை விகிதத்தைக் கட்டுப்படுத்துவதன் மூலம், விகித வரம்பிடல் சேவையகங்கள் அதிக சுமையடைவதைத் தடுக்கிறது, இது வேகமான மறுமொழி நேரங்கள் மற்றும் ஒட்டுமொத்த கணினி செயல்திறனை மேம்படுத்த வழிவகுக்கிறது.
• செலவு மேலாண்மை: கிளவுட் அடிப்படையிலான சேவைகளுக்கு, எதிர்பாராத கட்டணங்களுக்கு வழிவகுக்கும் அதிகப்படியான பயன்பாட்டைத் தடுப்பதன் மூலம் செலவுகளைக் கட்டுப்படுத்த விகித வரம்பிடல் உதவும்.

பொதுவான விகித வரம்பிடல் வழிமுறைகள்

விகித வரம்பிடலைச் செயல்படுத்த பல வழிமுறைகளைப் பயன்படுத்தலாம். சில பொதுவானவை பின்வருமாறு:

• டோக்கன் பக்கெட்: இந்த வழிமுறை டோக்கன்களை வைத்திருக்கும் ஒரு கருத்தியல் "பக்கெட்டை" பயன்படுத்துகிறது. ஒவ்வொரு கோரிக்கையும் ஒரு டோக்கனைப் பயன்படுத்துகிறது. பக்கெட் காலியாக இருந்தால், கோரிக்கை நிராகரிக்கப்படும். ஒரு வரையறுக்கப்பட்ட விகிதத்தில் பக்கெட்டில் டோக்கன்கள் சேர்க்கப்படுகின்றன.
• லீக்கி பக்கெட்: டோக்கன் பக்கெட்டைப் போன்றது, ஆனால் கோரிக்கைகள் வருகை விகிதத்தைப் பொருட்படுத்தாமல் ஒரு நிலையான விகிதத்தில் செயலாக்கப்படுகின்றன. அதிகப்படியான கோரிக்கைகள் வரிசைப்படுத்தப்படுகின்றன அல்லது கைவிடப்படுகின்றன.
• நிலையான சாளர கவுண்டர்: இந்த வழிமுறை நேரத்தை நிலையான அளவு சாளரங்களாகப் பிரிக்கிறது மற்றும் ஒவ்வொரு சாளரத்திலும் உள்ள கோரிக்கைகளின் எண்ணிக்கையை கணக்கிடுகிறது. வரம்பை அடைந்ததும், சாளரம் மீட்டமைக்கப்படும் வரை அடுத்தடுத்த கோரிக்கைகள் நிராகரிக்கப்படும்.
• ஸ்லைடிங் விண்டோ லாக்: இந்த அணுகுமுறை ஒரு ஸ்லைடிங் சாளரத்திற்குள் கோரிக்கை நேர முத்திரைகளின் ஒரு பதிவேட்டைப் பராமரிக்கிறது. சாளரத்திற்குள் உள்ள கோரிக்கைகளின் எண்ணிக்கை பதிவேட்டின் அடிப்படையில் கணக்கிடப்படுகிறது.
• ஸ்லைடிங் விண்டோ கவுண்டர்: மேம்பட்ட துல்லியத்திற்காக நிலையான சாளரம் மற்றும் ஸ்லைடிங் சாளர வழிமுறைகளின் அம்சங்களை இணைக்கும் ஒரு கலப்பின அணுகுமுறை.

இந்த வலைப்பதிவு இடுகை டோக்கன் பக்கெட் வழிமுறையில் அதன் நெகிழ்வுத்தன்மை மற்றும் பரந்த பயன்பாட்டிற்காக கவனம் செலுத்தும்.

டோக்கன் பக்கெட் வழிமுறை: ஒரு விரிவான விளக்கம்

டோக்கன் பக்கெட் வழிமுறை என்பது எளிமை மற்றும் செயல்திறனுக்கு இடையில் ஒரு சமநிலையை வழங்கும் பரவலாகப் பயன்படுத்தப்படும் விகித வரம்பிடல் நுட்பமாகும். இது டோக்கன்களை வைத்திருக்கும் ஒரு "பக்கெட்டை" கருத்தியல் ரீதியாக பராமரிப்பதன் மூலம் செயல்படுகிறது. உள்வரும் ஒவ்வொரு கோரிக்கையும் பக்கெட்டிலிருந்து ஒரு டோக்கனைப் பயன்படுத்துகிறது. பக்கெட்டில் போதுமான டோக்கன்கள் இருந்தால், கோரிக்கை அனுமதிக்கப்படுகிறது; இல்லையெனில், கோரிக்கை நிராகரிக்கப்படுகிறது (அல்லது செயல்படுத்தலைப் பொறுத்து வரிசைப்படுத்தப்படுகிறது). ஒரு வரையறுக்கப்பட்ட விகிதத்தில் பக்கெட்டில் டோக்கன்கள் சேர்க்கப்பட்டு, கிடைக்கும் திறனை மீண்டும் நிரப்புகின்றன.

முக்கிய கருத்துக்கள்

• பக்கெட் கொள்ளளவு: பக்கெட் வைத்திருக்கக்கூடிய அதிகபட்ச டோக்கன்களின் எண்ணிக்கை. இது திடீர் எழுச்சி கொள்ளளவைத் தீர்மானிக்கிறது, ஒரு குறிப்பிட்ட எண்ணிக்கையிலான கோரிக்கைகளை விரைவாகச் செயலாக்க அனுமதிக்கிறது.
• மீள்நிரப்பு விகிதம்: பக்கெட்டில் டோக்கன்கள் சேர்க்கப்படும் விகிதம், பொதுவாக வினாடிக்கு டோக்கன்கள் (அல்லது வேறு நேர அலகு) என அளவிடப்படுகிறது. இது கோரிக்கைகள் செயலாக்கப்படக்கூடிய சராசரி விகிதத்தைக் கட்டுப்படுத்துகிறது.
• கோரிக்கை நுகர்வு: உள்வரும் ஒவ்வொரு கோரிக்கையும் பக்கெட்டிலிருந்து ஒரு குறிப்பிட்ட எண்ணிக்கையிலான டோக்கன்களைப் பயன்படுத்துகிறது. பொதுவாக, ஒவ்வொரு கோரிக்கையும் ஒரு டோக்கனைப் பயன்படுத்துகிறது, ஆனால் மிகவும் சிக்கலான சூழ்நிலைகள் வெவ்வேறு வகையான கோரிக்கைகளுக்கு வெவ்வேறு டோக்கன் செலவுகளை ஒதுக்கலாம்.

இது எப்படி வேலை செய்கிறது

1. ஒரு கோரிக்கை வரும்போது, வழிமுறை பக்கெட்டில் போதுமான டோக்கன்கள் உள்ளதா எனச் சரிபார்க்கும்.
2. போதுமான டோக்கன்கள் இருந்தால், கோரிக்கை அனுமதிக்கப்பட்டு, அதற்கான டோக்கன்களின் எண்ணிக்கை பக்கெட்டிலிருந்து அகற்றப்படும்.
3. போதுமான டோக்கன்கள் இல்லை என்றால், கோரிக்கை நிராகரிக்கப்படும் ("Too Many Requests" பிழை, பொதுவாக HTTP 429) அல்லது பின்னர் செயலாக்கத்திற்காக வரிசைப்படுத்தப்படும்.
4. கோரிக்கை வருகையைப் பொருட்படுத்தாமல், பக்கெட்டின் கொள்ளளவு வரை, வரையறுக்கப்பட்ட மீள்நிரப்பு விகிதத்தில் அவ்வப்போது டோக்கன்கள் பக்கெட்டில் சேர்க்கப்படுகின்றன.

உதாரணம்

10 டோக்கன்கள் கொள்ளளவு மற்றும் வினாடிக்கு 2 டோக்கன்கள் மீள்நிரப்பு விகிதம் கொண்ட ஒரு டோக்கன் பக்கெட்டை கற்பனை செய்து பாருங்கள். ஆரம்பத்தில், பக்கெட் நிரம்பியுள்ளது (10 டோக்கன்கள்). வழிமுறை எவ்வாறு செயல்படலாம் என்பது இங்கே:

• வினாடி 0: 5 கோரிக்கைகள் வருகின்றன. பக்கெட்டில் போதுமான டோக்கன்கள் உள்ளன, எனவே அனைத்து 5 கோரிக்கைகளும் அனுமதிக்கப்படுகின்றன, இப்போது பக்கெட்டில் 5 டோக்கன்கள் உள்ளன.
• வினாடி 1: கோரிக்கைகள் எதுவும் வரவில்லை. 2 டோக்கன்கள் பக்கெட்டில் சேர்க்கப்படுகின்றன, மொத்தத்தை 7 டோக்கன்களாகக் கொண்டுவருகிறது.
• வினாடி 2: 4 கோரிக்கைகள் வருகின்றன. பக்கெட்டில் போதுமான டோக்கன்கள் உள்ளன, எனவே அனைத்து 4 கோரிக்கைகளும் அனுமதிக்கப்படுகின்றன, இப்போது பக்கெட்டில் 3 டோக்கன்கள் உள்ளன. மேலும் 2 டோக்கன்கள் சேர்க்கப்பட்டு, மொத்தத்தை 5 டோக்கன்களாகக் கொண்டுவருகிறது.
• வினாடி 3: 8 கோரிக்கைகள் வருகின்றன. 5 கோரிக்கைகள் மட்டுமே அனுமதிக்கப்படலாம் (பக்கெட்டில் 5 டோக்கன்கள் உள்ளன), மீதமுள்ள 3 கோரிக்கைகள் நிராகரிக்கப்படுகின்றன அல்லது வரிசைப்படுத்தப்படுகின்றன. மேலும் 2 டோக்கன்கள் சேர்க்கப்பட்டு, மொத்தத்தை 2 டோக்கன்களாகக் கொண்டுவருகிறது (5 கோரிக்கைகள் மீள்நிரப்பு சுழற்சிக்கு முன் வழங்கப்பட்டால், அல்லது மீள்நிரப்பு கோரிக்கைகளை வழங்குவதற்கு முன் நடந்தால் 7).

டோக்கன் பக்கெட் வழிமுறையைச் செயல்படுத்துதல்

டோக்கன் பக்கெட் வழிமுறையை பல்வேறு நிரலாக்க மொழிகளில் செயல்படுத்தலாம். கோலாங், பைத்தான் மற்றும் ஜாவாவில் எடுத்துக்காட்டுகள் இங்கே:

கோலாங்

```go package main import ( "fmt" "sync" "time" ) // TokenBucket ஒரு டோக்கன் பக்கெட் விகித வரம்பைக் குறிக்கிறது. type TokenBucket struct { capacity int tokens int rate time.Duration lastRefill time.Time mu sync.Mutex } // NewTokenBucket ஒரு புதிய TokenBucket-ஐ உருவாக்குகிறது. func NewTokenBucket(capacity int, rate time.Duration) *TokenBucket { return &TokenBucket{ capacity: capacity, tokens: capacity, rate: rate, lastRefill: time.Now(), } } // Allow டோக்கன் கிடைப்பதன் அடிப்படையில் ஒரு கோரிக்கை அனுமதிக்கப்பட்டுள்ளதா என சரிபார்க்கிறது. func (tb *TokenBucket) Allow() bool { tb.mu.Lock() defer tb.mu.Unlock() now := time.Now() tb.refill(now) if tb.tokens > 0 { tb.tokens-- return true } return false } // refill கடந்த நேரத்தின் அடிப்படையில் பக்கெட்டில் டோக்கன்களை சேர்க்கிறது. func (tb *TokenBucket) refill(now time.Time) { elapsed := now.Sub(tb.lastRefill) newTokens := int(elapsed.Seconds() * float64(tb.capacity) / tb.rate.Seconds()) if newTokens > 0 { tb.tokens += newTokens if tb.tokens > tb.capacity { tb.tokens = tb.capacity } tb.lastRefill = now } } func main() { bucket := NewTokenBucket(10, time.Second) for i := 0; i < 15; i++ { if bucket.Allow() { fmt.Printf("கோரிக்கை %d அனுமதிக்கப்பட்டது\n", i+1) } else { fmt.Printf("கோரிக்கை %d விகித வரம்புக்குட்பட்டது\n", i+1) } time.Sleep(100 * time.Millisecond) } } ```

பைத்தான்

```python import time import threading class TokenBucket: def __init__(self, capacity, refill_rate): self.capacity = capacity self.tokens = capacity self.refill_rate = refill_rate self.last_refill = time.time() self.lock = threading.Lock() def allow(self): with self.lock: self._refill() if self.tokens > 0: self.tokens -= 1 return True return False def _refill(self): now = time.time() elapsed = now - self.last_refill new_tokens = elapsed * self.refill_rate self.tokens = min(self.capacity, self.tokens + new_tokens) self.last_refill = now if __name__ == '__main__': bucket = TokenBucket(capacity=10, refill_rate=2) # 10 டோக்கன்கள், வினாடிக்கு 2 மீள்நிரம்பும் for i in range(15): if bucket.allow(): print(f"கோரிக்கை {i+1} அனுமதிக்கப்பட்டது") else: print(f"கோரிக்கை {i+1} விகித வரம்புக்குட்பட்டது") time.sleep(0.1) ```

ஜாவா

```java import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.TimeUnit; public class TokenBucket { private final int capacity; private double tokens; private final double refillRate; private long lastRefillTimestamp; private final ReentrantLock lock = new ReentrantLock(); public TokenBucket(int capacity, double refillRate) { this.capacity = capacity; this.tokens = capacity; this.refillRate = refillRate; this.lastRefillTimestamp = System.nanoTime(); } public boolean allow() { try { lock.lock(); refill(); if (tokens >= 1) { tokens -= 1; return true; } else { return false; } } finally { lock.unlock(); } } private void refill() { long now = System.nanoTime(); double elapsedTimeInSeconds = (double) (now - lastRefillTimestamp) / TimeUnit.NANOSECONDS.toNanos(1); double newTokens = elapsedTimeInSeconds * refillRate; tokens = Math.min(capacity, tokens + newTokens); lastRefillTimestamp = now; } public static void main(String[] args) throws InterruptedException { TokenBucket bucket = new TokenBucket(10, 2); // 10 டோக்கன்கள், வினாடிக்கு 2 மீள்நிரம்பும் for (int i = 0; i < 15; i++) { if (bucket.allow()) { System.out.println("கோரிக்கை " + (i + 1) + " அனுமதிக்கப்பட்டது"); } else { System.out.println("கோரிக்கை " + (i + 1) + " விகித வரம்புக்குட்பட்டது"); } TimeUnit.MILLISECONDS.sleep(100); } } } ```

டோக்கன் பக்கெட் வழிமுறையின் நன்மைகள்

• நெகிழ்வுத்தன்மை: டோக்கன் பக்கெட் வழிமுறை மிகவும் நெகிழ்வானது மற்றும் வெவ்வேறு விகித வரம்பிடல் சூழ்நிலைகளுக்கு எளிதாக மாற்றியமைக்கப்படலாம். பக்கெட் கொள்ளளவு மற்றும் மீள்நிரப்பு விகிதத்தை சரிசெய்வதன் மூலம் விகித வரம்பிடல் நடத்தையை நுட்பமாக மாற்றலாம்.
• திடீர் எழுச்சி கையாளுதல்: பக்கெட் கொள்ளளவு ஒரு குறிப்பிட்ட அளவு திடீர் எழுச்சி போக்குவரத்தை விகித வரம்பிடல் இல்லாமல் செயலாக்க அனுமதிக்கிறது. அவ்வப்போது ஏற்படும் போக்குவரத்து அதிகரிப்புகளைக் கையாள இது பயனுள்ளதாக இருக்கும்.
• எளிமை: இந்த வழிமுறை புரிந்துகொள்வதற்கும் செயல்படுத்துவதற்கும் ஒப்பீட்டளவில் எளிமையானது.
• கட்டமைக்கும் திறன்: இது சராசரி கோரிக்கை விகிதம் மற்றும் திடீர் எழுச்சி கொள்ளளவு மீது துல்லியமான கட்டுப்பாட்டை அனுமதிக்கிறது.

டோக்கன் பக்கெட் வழிமுறையின் தீமைகள்

• சிக்கலானது: கருத்தில் எளிமையானதாக இருந்தாலும், பக்கெட் நிலை மற்றும் மீள்நிரப்பு செயல்முறையை நிர்வகிப்பதற்கு கவனமான செயல்படுத்தல் தேவைப்படுகிறது, குறிப்பாக விநியோகிக்கப்பட்ட அமைப்புகளில்.
• சீரற்ற விநியோகத்திற்கான சாத்தியம்: சில சூழ்நிலைகளில், திடீர் எழுச்சி கொள்ளளவு காலப்போக்கில் கோரிக்கைகளின் சீரற்ற விநியோகத்திற்கு வழிவகுக்கும்.
• கட்டமைப்பு கூடுதல் சுமை: உகந்த பக்கெட் கொள்ளளவு மற்றும் மீள்நிரப்பு விகிதத்தைத் தீர்மானிப்பதற்கு கவனமான பகுப்பாய்வு மற்றும் பரிசோதனை தேவைப்படலாம்.

டோக்கன் பக்கெட் வழிமுறையின் பயன்பாட்டு நிகழ்வுகள்

டோக்கன் பக்கெட் வழிமுறை பரந்த அளவிலான விகித வரம்பிடல் பயன்பாட்டு நிகழ்வுகளுக்கு ஏற்றது, அவற்றுள்:

• API விகித வரம்பிடல்: பயனர் அல்லது வாடிக்கையாளருக்கான கோரிக்கைகளின் எண்ணிக்கையைக் கட்டுப்படுத்துவதன் மூலம் APIகளை துஷ்பிரயோகத்திலிருந்து பாதுகாப்பது மற்றும் நியாயமான பயன்பாட்டை உறுதி செய்தல். உதாரணமாக, ஒரு சமூக ஊடக API, ஒரு பயனர் ஒரு மணி நேரத்திற்கு செய்யக்கூடிய பதிவுகளின் எண்ணிக்கையை வரம்பிடுவதன் மூலம் ஸ்பேமைத் தடுக்கலாம்.
• வலை பயன்பாட்டு விகித வரம்பிடல்: பயனர்கள் வலை சேவையகங்களுக்கு அதிகப்படியான கோரிக்கைகளைச் செய்வதைத் தடுத்தல், அதாவது படிவங்களைச் சமர்ப்பிப்பது அல்லது ஆதாரங்களை அணுகுவது. ஒரு ஆன்லைன் வங்கி பயன்பாடு, முரட்டுத்தனமான தாக்குதல்களைத் தடுக்க கடவுச்சொல் மீட்டமைப்பு முயற்சிகளின் எண்ணிக்கையை வரம்பிடலாம்.
• நெட்வொர்க் விகித வரம்பிடல்: ஒரு குறிப்பிட்ட பயன்பாடு அல்லது பயனர் பயன்படுத்தும் அலைவரிசையைக் கட்டுப்படுத்துவது போன்ற ஒரு நெட்வொர்க் வழியாக பாயும் போக்குவரத்தின் விகிதத்தைக் கட்டுப்படுத்துதல். ISPக்கள் பெரும்பாலும் நெட்வொர்க் நெரிசலை நிர்வகிக்க விகித வரம்பிடலைப் பயன்படுத்துகின்றன.
• செய்தி வரிசை விகித வரம்பிடல்: நுகர்வோர் அதிகமாக பாதிக்கப்படுவதைத் தடுக்கும் வகையில், ஒரு செய்தி வரிசையால் செய்திகள் செயலாக்கப்படும் விகிதத்தைக் கட்டுப்படுத்துதல். சேவைகள் செய்தி வரிசைகள் வழியாக ஒத்திசைவற்ற முறையில் தொடர்பு கொள்ளும் மைக்ரோசர்வீஸ் கட்டமைப்புகளில் இது பொதுவானது.
• மைக்ரோசர்வீஸ் விகித வரம்பிடல்: பிற சேவைகள் அல்லது வெளிப்புற வாடிக்கையாளர்களிடமிருந்து பெறும் கோரிக்கைகளின் எண்ணிக்கையைக் கட்டுப்படுத்துவதன் மூலம் தனிப்பட்ட மைக்ரோசர்வீஸ்களை அதிக சுமையிலிருந்து பாதுகாத்தல்.

விநியோகிக்கப்பட்ட அமைப்புகளில் டோக்கன் பக்கெட்டை செயல்படுத்துதல்

ஒரு விநியோகிக்கப்பட்ட அமைப்பில் டோக்கன் பக்கெட் வழிமுறையைச் செயல்படுத்துவதற்கு நிலைத்தன்மையை உறுதி செய்வதற்கும் ரேஸ் நிலைமைகளைத் தவிர்ப்பதற்கும் சிறப்புப் பரிசீலனைகள் தேவை. சில பொதுவான அணுகுமுறைகள் இங்கே:

• மையப்படுத்தப்பட்ட டோக்கன் பக்கெட்: ஒரு ஒற்றை, மையப்படுத்தப்பட்ட சேவை அனைத்து பயனர்கள் அல்லது வாடிக்கையாளர்களுக்கான டோக்கன் பக்கெட்டுகளை நிர்வகிக்கிறது. இந்த அணுகுமுறை செயல்படுத்த எளிதானது, ஆனால் இது ஒரு இடையூறாகவும், ஒற்றை தோல்வி புள்ளியாகவும் மாறும்.
• ரெடிஸுடன் விநியோகிக்கப்பட்ட டோக்கன் பக்கெட்: ரெடிஸ், ஒரு நினைவகத்தில் உள்ள தரவுக்களஞ்சியம், டோக்கன் பக்கெட்டுகளை சேமிக்கவும் நிர்வகிக்கவும் பயன்படுத்தப்படலாம். ரெடிஸ் அணு செயல்பாடுகளை வழங்குகிறது, இது ஒரு போட்டி சூழலில் பக்கெட் நிலையை பாதுகாப்பாகப் புதுப்பிக்கப் பயன்படுகிறது.
• கிளையன்ட்-பக்க டோக்கன் பக்கெட்: ஒவ்வொரு கிளையன்ட்டும் அதன் சொந்த டோக்கன் பக்கெட்டைப் பராமரிக்கிறது. இந்த அணுகுமுறை மிகவும் அளவிடக்கூடியது, ஆனால் விகித வரம்பிடல் மீது மையக் கட்டுப்பாடு இல்லாததால் இது துல்லியமற்றதாக இருக்கலாம்.
• கலப்பின அணுகுமுறை: மையப்படுத்தப்பட்ட மற்றும் விநியோகிக்கப்பட்ட அணுகுமுறைகளின் அம்சங்களை இணைத்தல். உதாரணமாக, டோக்கன் பக்கெட்டுகளை சேமிக்க ஒரு விநியோகிக்கப்பட்ட தற்காலிக சேமிப்பு பயன்படுத்தப்படலாம், பக்கெட்டுகளை மீள்நிரப்புவதற்கு ஒரு மையப்படுத்தப்பட்ட சேவை பொறுப்பாகும்.

ரெடிஸைப் பயன்படுத்தி உதாரணம் (கருத்தியல்)

ஒரு விநியோகிக்கப்பட்ட டோக்கன் பக்கெட்டுக்கு ரெடிஸைப் பயன்படுத்துவது டோக்கன் எண்ணிக்கையை நிர்வகிக்க அதன் அணு செயல்பாடுகளை (`INCRBY`, `DECR`, `TTL`, `EXPIRE`) பயன்படுத்துவதை உள்ளடக்குகிறது. அடிப்படை ஓட்டம் பின்வருமாறு இருக்கும்:

1. இருக்கும் பக்கெட்டை சரிபார்க்கவும்: பயனர்/API இறுதிப்புள்ளிக்கான ஒரு கீ ரெடிஸில் உள்ளதா என்று பார்க்கவும்.
2. தேவைப்பட்டால் உருவாக்கவும்: இல்லையெனில், கீயை உருவாக்கி, டோக்கன் எண்ணிக்கையை கொள்ளளவுக்கு துவக்கி, மீள்நிரப்பு காலத்திற்குப் பொருந்தும் வகையில் ஒரு காலாவதியை (TTL) அமைக்கவும்.
3. டோக்கனை நுகர முயற்சிக்கவும்: அணுமுறையில் டோக்கன் எண்ணிக்கையைக் குறைக்கவும். முடிவு >= 0 ஆக இருந்தால், கோரிக்கை அனுமதிக்கப்படுகிறது.
4. டோக்கன் தீர்வைக் கையாளவும்: முடிவு < 0 ஆக இருந்தால், குறைப்பினைத் திரும்பப் பெறவும் (அணுமுறையில் மீண்டும் அதிகரிக்கவும்) மற்றும் கோரிக்கையை நிராகரிக்கவும்.
5. மீள்நிரப்பு தர்க்கம்: ஒரு பின்னணி செயல்முறை அல்லது குறிப்பிட்ட கால இடைவெளியில் செயல்படும் பணி பக்கெட்டுகளை மீள்நிரப்பலாம், கொள்ளளவு வரை டோக்கன்களை சேர்க்கலாம்.

விநியோகிக்கப்பட்ட செயலாக்கங்களுக்கான முக்கிய பரிசீலனைகள்:

• அணுத்தன்மை: ஒரு போட்டி சூழலில் டோக்கன் எண்ணிக்கைகள் சரியாகப் புதுப்பிக்கப்படுவதை உறுதிசெய்ய அணு செயல்பாடுகளைப் பயன்படுத்தவும்.
• நிலைத்தன்மை: விநியோகிக்கப்பட்ட அமைப்பின் அனைத்து முனைகளிலும் டோக்கன் எண்ணிக்கைகள் சீராக இருப்பதை உறுதி செய்யவும்.
• தவறு சகிப்புத்தன்மை: சில முனைகள் தோல்வியுற்றாலும் அமைப்பு தொடர்ந்து செயல்படும் வகையில் அமைப்பை வடிவமைக்கவும்.
• அளவிடுதல்: தீர்வு அதிக எண்ணிக்கையிலான பயனர்களையும் கோரிக்கைகளையும் கையாளும் வகையில் அளவிடப்பட வேண்டும்.
• கண்காணிப்பு: விகித வரம்பிடலின் செயல்திறனைக் கண்காணிக்கவும் மற்றும் ஏதேனும் சிக்கல்களைக் கண்டறியவும் கண்காணிப்பைச் செயல்படுத்தவும்.

டோக்கன் பக்கெட்டிற்கான மாற்று வழிகள்

டோக்கன் பக்கெட் வழிமுறை ஒரு பிரபலமான தேர்வாக இருந்தாலும், குறிப்பிட்ட தேவைகளைப் பொறுத்து மற்ற விகித வரம்பிடல் நுட்பங்கள் மிகவும் பொருத்தமானதாக இருக்கலாம். சில மாற்று வழிகளுடன் ஒரு ஒப்பீடு இங்கே:

• லீக்கி பக்கெட்: டோக்கன் பக்கெட்டை விட எளிமையானது. இது ஒரு நிலையான விகிதத்தில் கோரிக்கைகளை செயலாக்குகிறது. போக்குவரத்தை சீராக்க நல்லது, ஆனால் திடீர் எழுச்சிகளைக் கையாள்வதில் டோக்கன் பக்கெட்டை விட நெகிழ்வுத்தன்மை குறைவு.
• நிலையான சாளர கவுண்டர்: செயல்படுத்த எளிதானது, ஆனால் சாளர எல்லைகளில் இரண்டு மடங்கு விகித வரம்பை அனுமதிக்கலாம். டோக்கன் பக்கெட்டை விட துல்லியம் குறைவு.
• ஸ்லைடிங் விண்டோ லாக்: துல்லியமானது, ஆனால் இது அனைத்து கோரிக்கைகளையும் பதிவு செய்வதால் அதிக நினைவகத்தை எடுத்துக்கொள்ளும். துல்லியம் மிக முக்கியமான சூழ்நிலைகளுக்கு ஏற்றது.
• ஸ்லைடிங் விண்டோ கவுண்டர்: துல்லியம் மற்றும் நினைவக பயன்பாட்டிற்கு இடையிலான ஒரு சமரசம். ஸ்லைடிங் விண்டோ லாக்கை விட குறைவான நினைவகச் சுமையுடன் நிலையான சாளர கவுண்டரை விட சிறந்த துல்லியத்தை வழங்குகிறது.

சரியான வழிமுறையைத் தேர்ந்தெடுப்பது:

சிறந்த விகித வரம்பிடல் வழிமுறையின் தேர்வு போன்ற காரணிகளைப் பொறுத்தது:

• துல்லியத் தேவைகள்: விகித வரம்பு எவ்வளவு துல்லியமாகச் செயல்படுத்தப்பட வேண்டும்?
• திடீர் எழுச்சி கையாளுதல் தேவைகள்: குறுகிய கால திடீர் போக்குவரத்து எழுச்சிகளை அனுமதிக்க வேண்டியது அவசியமா?
• நினைவகக் கட்டுப்பாடுகள்: விகித வரம்பிடல் தரவைச் சேமிக்க எவ்வளவு நினைவகத்தை ஒதுக்க முடியும்?
• செயல்படுத்துதலின் சிக்கலான தன்மை: வழிமுறையைச் செயல்படுத்துவதும் பராமரிப்பதும் எவ்வளவு எளிது?
• அளவிடும் தேவைகள்: அதிக எண்ணிக்கையிலான பயனர்களையும் கோரிக்கைகளையும் கையாள வழிமுறை எவ்வளவு நன்றாக அளவிடப்படுகிறது?

விகித வரம்பிடலுக்கான சிறந்த நடைமுறைகள்

விகித வரம்பிடலை திறம்படச் செயல்படுத்த கவனமான திட்டமிடல் மற்றும் பரிசீலனை தேவை. பின்பற்ற வேண்டிய சில சிறந்த நடைமுறைகள் இங்கே:

• விகித வரம்புகளைத் தெளிவாக வரையறுக்கவும்: சேவையகத்தின் திறன், எதிர்பார்க்கப்படும் போக்குவரத்து முறைகள் மற்றும் பயனர்களின் தேவைகளின் அடிப்படையில் பொருத்தமான விகித வரம்புகளைத் தீர்மானிக்கவும்.
• தெளிவான பிழைச் செய்திகளை வழங்கவும்: ஒரு கோரிக்கை விகித வரம்புக்கு உட்படுத்தப்பட்டால், விகித வரம்புக்கான காரணம் மற்றும் அவர்கள் எப்போது மீண்டும் முயற்சி செய்யலாம் என்பது உட்பட (உதாரணமாக, `Retry-After` HTTP தலைப்பைப் பயன்படுத்தி) தெளிவான மற்றும் தகவலறிந்த பிழைச் செய்தியைப் பயனருக்குத் திருப்பவும்.
• நிலையான HTTP நிலைக் குறியீடுகளைப் பயன்படுத்தவும்: விகித வரம்பிடலைக் குறிக்க பொருத்தமான HTTP நிலைக் குறியீடுகளைப் பயன்படுத்தவும், அதாவது 429 (Too Many Requests).
• மென்மையான தரமிறக்கத்தை செயல்படுத்தவும்: கோரிக்கைகளை வெறுமனே நிராகரிப்பதற்குப் பதிலாக, சேவையின் தரத்தைக் குறைப்பது அல்லது செயலாக்கத்தைத் தாமதப்படுத்துவது போன்ற மென்மையான தரமிறக்கத்தைச் செயல்படுத்தவும்.
• விகித வரம்பிடல் அளவீடுகளைக் கண்காணிக்கவும்: விகித வரம்பிடல் பயனுள்ளதாக இருப்பதையும், எதிர்பாராத விளைவுகளை ஏற்படுத்தவில்லை என்பதையும் உறுதிசெய்ய, விகித வரம்பிடப்பட்ட கோரிக்கைகளின் எண்ணிக்கை, சராசரி மறுமொழி நேரம் மற்றும் பிற தொடர்புடைய அளவீடுகளைக் கண்காணிக்கவும்.
• விகித வரம்புகளை கட்டமைக்கக்கூடியதாக மாற்றவும்: மாறும் போக்குவரத்து முறைகள் மற்றும் கணினித் திறனின் அடிப்படையில் விகித வரம்புகளை மாறும் வகையில் சரிசெய்ய நிர்வாகிகளை அனுமதிக்கவும்.
• விகித வரம்புகளை ஆவணப்படுத்தவும்: API ஆவணத்தில் விகித வரம்புகளைத் தெளிவாக ஆவணப்படுத்தவும், இதன் மூலம் டெவலப்பர்கள் வரம்புகளை அறிந்திருக்கலாம் மற்றும் அதற்கேற்ப தங்கள் பயன்பாடுகளை வடிவமைக்கலாம்.
• தகவமைப்பு விகித வரம்பிடலைப் பயன்படுத்தவும்: தற்போதைய கணினி சுமை மற்றும் போக்குவரத்து முறைகளின் அடிப்படையில் விகித வரம்புகளைத் தானாக சரிசெய்யும் தகவமைப்பு விகித வரம்பிடலைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளவும்.
• விகித வரம்புகளை வேறுபடுத்தவும்: வெவ்வேறு வகையான பயனர்கள் அல்லது வாடிக்கையாளர்களுக்கு வெவ்வேறு விகித வரம்புகளைப் பயன்படுத்தவும். உதாரணமாக, அங்கீகரிக்கப்பட்ட பயனர்களுக்கு அநாமதேய பயனர்களை விட அதிக விகித வரம்புகள் இருக்கலாம். இதேபோல், வெவ்வேறு API இறுதிப்புள்ளிகள் வெவ்வேறு விகித வரம்புகளைக் கொண்டிருக்கலாம்.
• பிராந்திய மாறுபாடுகளைக் கருத்தில் கொள்ளவும்: நெட்வொர்க் நிலைமைகள் மற்றும் பயனர் நடத்தை வெவ்வேறு புவியியல் பிராந்தியங்களில் மாறுபடலாம் என்பதை அறிந்து கொள்ளுங்கள். பொருத்தமான இடங்களில் அதற்கேற்ப விகித வரம்புகளை வடிவமைக்கவும்.

முடிவுரை

மீள்தன்மை மற்றும் அளவிடக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கு விகித வரம்பிடல் ஒரு இன்றியமையாத நுட்பமாகும். டோக்கன் பக்கெட் வழிமுறை பயனர்கள் அல்லது வாடிக்கையாளர்கள் கோரிக்கைகளை அனுப்பக்கூடிய விகிதத்தைக் கட்டுப்படுத்த ஒரு நெகிழ்வான மற்றும் பயனுள்ள வழியை வழங்குகிறது, அமைப்புகளை துஷ்பிரயோகத்திலிருந்து பாதுகாக்கிறது, நியாயமான பயன்பாட்டை உறுதி செய்கிறது மற்றும் ஒட்டுமொத்த செயல்திறனை மேம்படுத்துகிறது. டோக்கன் பக்கெட் வழிமுறையின் கொள்கைகளைப் புரிந்துகொண்டு, செயல்படுத்தலுக்கான சிறந்த நடைமுறைகளைப் பின்பற்றுவதன் மூலம், டெவலப்பர்கள் மிகவும் கோரப்படும் போக்குவரத்து சுமைகளைக் கூட கையாளக்கூடிய வலுவான மற்றும் நம்பகமான அமைப்புகளை உருவாக்க முடியும்.

இந்த வலைப்பதிவு இடுகை டோக்கன் பக்கெட் வழிமுறை, அதன் செயல்படுத்தல், நன்மைகள், தீமைகள் மற்றும் பயன்பாட்டு நிகழ்வுகள் பற்றிய விரிவான கண்ணோட்டத்தை வழங்கியுள்ளது. இந்த அறிவைப் பயன்படுத்துவதன் மூலம், உங்கள் சொந்தப் பயன்பாடுகளில் விகித வரம்பிடலைத் திறம்படச் செயல்படுத்தலாம் மற்றும் உலகெங்கிலும் உள்ள பயனர்களுக்கு உங்கள் சேவைகளின் நிலைத்தன்மையையும் கிடைக்கும் தன்மையையும் உறுதிசெய்யலாம்.